Gaming machine transitions

ABSTRACT

A graphics system for changing images on a gaming machine display, having a transition library of transition types, a graphics engine and a control means. The graphics engine applies a selected transition type from the transition library to at least one of at least two images for determining the way in which a substitution of one of the images by the other of the images occurs and initialises transition data for effecting an incremental substitution of the one image by the other image. The control means modifies the transition data such that, when the selected transition type is being effected, an incremental substitution of at least a part of the one image by the other image occurs serially until the one image has been substituted by the other image on the gaming machine display.

FIELD OF THE INVENTION

This invention relates to gaming machines. More particularly, theinvention relates to a system and method for changing images on a gamingmachine display.

BACKGROUND OF THE INVENTION

When replacing one on-screen image with another in a gaming machine, theoptions available to perform this action in an interesting oraesthetically pleasing manner are limited. In fact, other than aninstantaneous change, the only way is to use some form of pre-generatedanimation. This method, apart from consuming a large amount of EPROMspace, is unwieldy and cumbersome given that the starting and end imagesmust be known before run-time.

In filmmaking, when going from one scene to another, filmmakers haveused a number of techniques. Theses techniques range from fading from ascene to black, and then fading from black into the next scene. Otheroptions are fading directly from one scene to another, shrinking a sceneto reveal another “behind it”, or sliding one scene off the screen tothe left whilst simultaneously sliding another onto the screen from theright. All these techniques are generated post-filming and are fixed.

SUMMARY OF THE INVENTION

According to a first aspect of the invention there is provided agraphics system for changing images on a gaming machine display, thesystem comprising:

a transition library of transition types;

a graphics engine to apply a selected transition type from thetransition library to at least one of at least two images fordetermining the way in which a substitution of one of the images by theother of the images occurs and for initialising transition data foreffecting an incremental substitution of the one image by the otherimage; and

a control means for modifying the transition data such that, when theselected transition type is being effected, an incremental substitutionof at least a part of the one image by the other image occurs seriallyuntil the one image has been substituted by the other image on thegaming machine display.

In a preferred embodiment as an initial step, a second of the images isinitially placed behind a first of the images. The first image may beincrementally removed by the transition type to reveal or expose atleast a part of the second image until the first image has been entirelyremoved to reveal the second image.

The transition library may include slide, wipe, scatter, fade, iris,shrink, curtain or rotate transitions. The selected transition type orselected transition may change the first image to the second image usinga shape. The iris transition may use a circle. The wipe transition mayuse a line. The scatter transition may use a square.

The selected transition may be drawn using pixel operations, scaling,micro-clipping or OpenGL operations.

The selected transition may have a pre-determined duration. The selectedtransition may coincide with a sound or animation. The selectedtransition may start and reset based on a pre-determined time.

At least one of the images may be an animation. In the preferredembodiment, only the second image is an animation. The images may bebitmap images, hereinafter referred to as 2D images. The images may bevector images, hereinafter referred to as 3D images. The selectedtransition may be in 2D mode if the first or second images are 2Dimages.

In 2D mode, the image may be divided into smaller shapes. Apre-determined number of smaller shapes may be filled for each refreshperiod of the gaming machine display.

In 3D mode, the transition data may include a callback function that isattached to the selected transition. A Display Manager window may becreated for the callback function. The callback function may draw theselected transition on the gaming machine display using OpenGL calls.The callback function may draw the selected transition on the gamingmachine display by incrementally exposing less of the first image foreach refresh period.

The first image may exist in a scene list. The selected transition maybe added in the same position of the first image in the scene list.

A duplicate image of the first image may be added to the scene list formodification. The transition data for the duplicate image may beinitialised.

The transition data may be generated and/or modified at every refreshperiod of the gaming machine display.

The transition data may be a duplicate image of the first image.

Transition data may include the transition type, the duration of theselected transition, the current state of the selected transition.

An offscreen Device Context may be created for receiving a copy of theduplicate image. The first image may be removed after the Device Contextis created.

The duplicate image in the offscreen Device Context may be added to aDisplay Manager. The image may be removed from the Display Manager whenthe selected transition is completed. Memory may be freed when theselected transition is removed from the Display Manager.

Each image in a scene list may be checked to determine if it hastransition data.

Each image having transition data may have a draw handler.

Parts of the first image to be replaced per refresh period may becalculated such that the selected transition is completed within apre-determined time. The pre-determined time may be set by a user atrun-time.

According to a second aspect of the invention, there is provided amethod for changing images on a gaming machine display, the methodcomprising the steps of:

selecting a transition from a transition library of transition types;

applying the selected transition to at least one of at least two imagesfor determining the way in which a substitution of one of the images bythe other of the images occurs;

initialising transition data for effecting an incremental substitutionof the one image by the other image; and

modifying the transition data such that, when the selected transitiontype is being effected, an incremental substitution of at least a partof the one image by the other image occurs serially until the one imagehas been substituted by the other image on the gaming machine display.

According to a third aspect of the invention, there is provided a gamingmachine having a gaming machine display, the gaming machine comprising:

a graphics system to change images on the gaming machine display, thegraphics system including:

a transition library of transition types;

a graphics engine for applying a selected transition type from thetransition library to at least one of at least two images fordetermining the way in which a substitution of one of the images by theother of the images occurs and for initialising transition data foreffecting an incremental substitution of the one image by the otherimage; and

a control means for modifying the transition data such that, when theselected transition type is being effected, an incremental substitutionof at least a part of the one image by the other image occurs seriallyuntil the one image has been substituted by the other image on thegaming machine display.

Advantageously, transitions enable gaming machines to change images onthe gaming display in a variety of ways over a variable time periodwithout using pre-generated animations. That is, any image that existson a gaming machine display can be made to disappear and reappearaesthetically at run-time. Preferably, by placing a second image underthe first image before the start of a transition, the second image canbe exposed and effectively replace the first image using any of thetransitions provided by the graphics engine.

According to a fourth aspect of the invention there is provided computerprogram means for directing a graphics engine and a control means toexecute a procedure to change images in a graphics system on a gamingmachine display, the graphics system having a transition library oftransition types, the computer program means directing:

the graphics engine to apply a selected transition type from thetransition library to at least one of at least two images fordetermining the way in which a substitution of one of the images by theother of the images occurs and for initialising transition data foreffecting an incremental substitution of the one image by the otherimage,

the computer program means further directing the control means to modifythe transition data such that when the selected transition type is beingeffected, an incremental substitution of at least a part of the oneimage by the other image occurs serially until the one image has beensubstituted by the other image on the gaming machine display.

According a fifth aspect of the invention there is provided computerprogram means for directing a graphics engine and a control means toexecute a procedure to change images on a gaming machine display by:

selecting a transition type from a transition library of transitiontypes;

applying the selected transition type to at least one of at least twoimages for determining the way in which a substitution of one of theimages by the other of the images occurs;

initialising transition data for effecting an incremental substitutionof the one image by the other image;

modifying the transition data such that when the selected transitiontype is being effected, an incremental substitution of at least a partof the one image by the other image occurs serially until the one imagehas been substituted by the other image on the gaming machine display.

According to a sixth aspect of the invention there is provided acomputer readable memory, encoded with data representing a computerprogram for directing a graphics engine and a control means to execute aprocedure to change images on a gaming machine display by:

selecting a transition type from a transition library of transitiontypes;

applying the selected transition type to at least one of at least twoimages for determining the way in which a substitution of one of theimages by the other of the images occurs;

initialising transition data for effecting an incremental substitutionof the one image by the other image;

modifying the transition data such that when the selected transitiontype is being effected, an incremental substitution of at least a partof the one image by the other image occurs serially until the one imagehas been substituted by the other image on the gaming machine display.

BRIEF DESCRIPTION OF THE DRAWINGS

An example of the invention will now be described with reference to theaccompanying drawings, in which:

FIG. 1 is a block diagram of the graphics system.

FIG. 2 is a process flow diagram of a 3D transition using 3D callback.

FIG. 3 is a process flow diagram of adding a transition image to theDisplay Manager.

FIG. 4 is a process flow diagram of a 3D transition not using 3Dcallback.

FIG. 5 is a process flow diagram of a 2D transition.

FIG. 6 is a process flow diagram of a diagonal wipe 3D callback.

FIG. 7 is a process flow diagram of a 2D diagonal wipe transition.

FIG. 8 illustrates how the scatter transition separates an image.

FIG. 9 is a process flow diagram for the drawing procedure of theScatter transition.

FIGS. 10 a-c are a series of images illustrating the Wipe transition.

FIGS. 11 a-c are a series of images illustrating the Fade transition.

FIGS. 12 a-c are a series of images illustrating the Iris transition.

DETAILED DESCRIPTION OF THE DRAWINGS

Referring to FIG. 1, a graphics system 10 for a gaming machine 20comprises a transition library 12 which stores various types oftransitions, for example, slide, wipe, scatter, fade, iris, shrink,curtain and rotate transitions. The graphics system 10 also provides agraphics engine 14 to apply a selected transition type from thetransition library 12 to one of two images for determining the way inwhich a substitution of a first image by a second image occurs. Thegraphics engine 14 also initialises transition data (t_data) foreffecting an incremental removal of the first image to reveal the secondimage. A control means 16 modifies the transition data (t_data) suchthat when the selected transition type is being effected, an incrementalremoval of at least a part of the first image by the second image occursserially until the first image has been removed in its entirety toreveal the second image on a display 18 of the gaming machine 20.

Referring to FIG. 2, the graphics engine 14 executes an application codethread 25, scene_update_task thread 30 and scene3d_update_task thread40. There are three main functions to facilitate image transitions.Firstly, the application code thread 25 has an _addtransition( )function 26 which selects a transition and initialises its transitiondata (t_data) structure and attaches it to an image. Secondly, thescene_update_task thread 30 has an _updatescene( ) function 31 whichinterrogates images within the scene list to determine whether they havetransition data (t_data).

Thirdly, if transition data (t_data) is found, the transition_actions( )function 32 of the scene_update_task thread 30 is called to maintainand/or update the selected transition.

The scene3d_update_task thread 40 is used for 3D images and is providedwith functions including: scenerender( ) 41, _refreshDMEx( ) 42,_refreshDM( ) 43 and a 3D transition callback function,diag_wipe3d_cb_DM( ) 44. The scene3d_update_task thread 40 callst_refreshDM( ) 43 to call the 3D transition callback function 44. Thecallback function 44 uses the transition data (t_data) attached to theimage to draw the selected transition via OpenGL calls. For anyindividual transition, the application code and scene_update_task 30threads cannot run concurrently. Also, the scene3d_update_task 40 andscene_update_task 30 threads cannot run concurrently.

Addtransition( )

Referring to FIGS. 2, 4 and 5, the application code thread 25 calls the_addtransition( ) function 26 to attach the selected transition to animage. Applying a transition to an image requires the name and positionof the subject image to be known. Unless these are correct, thetransition command is ignored. The command itself both identifies thesubject image and specifies the transition parameters as shown in thecode below: Transition_scene_id = addtransition   (    image identifier,   screen position x,    screen position y,    transition type,   direction,    duration   )

The variable “Transition_scene_id” is used with the existing graphicscommands to both start and reset the transition at desired times.Resetting a transition is useful to reveal several consecutive images,or if the transition has been interrupted by another gaming machineevent.

When _addtransition( ) 26 is called, the selected transition assumesthat the image already exists in the scene list and DM (DisplayManager). An example of calling the _addtransition( ) function 26 isshown below: H_OBJECT tmp; tmp = getobjecthandle(“IMG_SYM_TEN”, _IMAGE);s_id1 = addscene(tmp, 100, 100, 0, 0, HIGHER_PRI); t_id1 =addtransition(tmp, 100, 100, SLIDE, TOP_LEFT, 3200);_controlscene(s_id1, SCENE_START); _controlscene(t_id1,SCENE_START_TRANS);

The transition (t_id1) is added in the same position that the imageexists in for tile scene (s_id1). If this procedure is not met, then_addtransition( ) 26 will fail. The following code extract shows how_addtransition( ) 26 searches for the resource in the DM (DisplayManager) and checks if the resource is in the same location that theuser wants to attach the transition to. DmItem =FindResourceDM(pImage->hDc, −1); _getitempositionDM(DmItem, &Rect);while (DmItem != −1) {   if (Rect.top == yPos && Rect.left == xPos)   {   _getscenedataDM(DmItem, &scene_id);    break;   }   else   {   DmItem = FindResourceDM(pImage->hDc, DmItem);   _getitempositionDM(DmItem, &Rect);   } } ... // Could not find theobject at that spot.   if (DmItem == −1)    return GRERROR;

Next, _addtransition( ) 26 adds a duplicate of the image to the scenelist so that it can modify the duplicate image for the transition.

_addtransition( ) 26 also initialises all transition data (t_data)variables for the associated duplicate image. Below is a code extractthat details the initialisation of the transition data (t_data).scene_list[new_scene_index].t_data = (TRANS_ITEM*)_avlmalloc(sizeof(TRANS_ITEM))scene_list[new_scene_index].t_data->swansong = swansong;scene_list[new_scene_index].t_data->direction = dir;scene_list[new_scene_index].t_data->duration = dur;scene_list[new_scene_index].t_data->status = NOT_YET_STARTED;scene_list[new_scene_index].t_data->curr_x = 0;scene_list[new_scene_index].t_data->curr_y = 0;scene_list[new_scene_index].t_data->generic1 = 0;scene_list[new_scene_index].t_data->generic2 = 0;scene_list[new_scene_index].t_data->generic3 = 0;scene_list[new_scene_index].t_data->generic4 = 0;scene_list[new_scene_index].t_data->generic5 = 0;scene_list[new_scene_index].t_data->generic6 = 0;scene_list[new_scene_index].t_data->cllbckDMitem = −1;scene_list[new_scene_index].t_data->randomlist = (NLIST *) 0;scene_list[new_scene_index].t_data->randomlist3D = (int *) 0;

Many of the variables within the t_data structure are dependent on thetype of transition chosen, however some are present for all transitions.Below is a table explaining the variables of the t_data structure.T_data variable Meaning swansong Type of transition direction Depends ontransition chosen as different transitions have differentsubtypes/directions duration Length of transition status Current stateof the transition generic1-generic6 All these variables are differentfor each transition cllbckDMitem This refers to the callback functionthat is attached to the transition in 3D mode when a window is created.randomlist This is the list of squares to be removed. Specific for theSCATTER transition in 2D mode. randomlist3D This is the list of squaresto be removed. Specific for the SCATTER transition in 3D mode.

If the selected transition requires modification of the original image,for example, the “Iris Wipe” transition, an offscreen DC (DeviceContext) is created for a duplicate transition image. Below is a list oftransitions that do not require an offscreen DC (Device Context) to becreated. Transition 2D/3D ROTATE 3D SHRINK ANY SLIDE ANY FADE 3D WIPEANY, wipes in left, right, up and down do not need to create a DC eitheras we are doing micro clipping and this does not affect the originalimage. IRIS 3D SCATTER 3D CURTAIN 3D

Referring to FIG. 3, when an offscreen DC (Device Context) has beencreated for a duplicate transition image, the original image is removed.In 3D mode after the offscreen DC has been created, cloneimageitemDM( )51 is called which adds the transition image DC to the DM (DisplayManager). However, in 2D mode, a _bitblt( ) 52 is done to copy theduplicate image to the DC. Next, _additemDM( ) 53 is called to add thetransition image DC to the DM (Display Manager).

For error handling purposes, applying a transition to a resource otherthan an image results in _addtransition( ) 26 returning an error.

Updatescene( )

In the image transition process, the updatescene( ) function 31 iscalled for each refresh of the gaming display 18. Also, each image to bedisplayed is checked to see if it contains any transition data. If theimage contains transition data (t_data) and the transition is inprogress, transition_actions( ) 32 is called as shown in the codeextract below: if (scene_list[i].t_data != 0 &&scene_list[i].t_data->status == IN_PROGRESS)    transition_actions(i,&callback_reqd);Transition Actions( )

Transitions are maintained and updated by the transition_actions( )function 32. Transitions can be updated using pixel operations or wholeimage operations, for example, scaling. The transition_actions( )function 32 modifies all the transition data (t_data) for the nextrefresh of the display 18. Each individual transition contains uniquealgorithms and procedures to remove parts of the image from the display18. However, some of the transitions within transition_actions( ) 32only have a 2D implementation. Other transitions have a 2D and 3D)implementation. The transitions that are only available in 2D use aspecific 3D callback function 44 to cater for those, transitions in 3Dmode.

If in 3D mode, the first time transition_actions( ) 32 is called, a DM(Display Manager) window is created at the location of the image andattaches a 3D callback function 44 to this window. At every refresh,transition_actions( ) 32 modifies all the t_data. Also, the 3D callbackfunction 44 attached to this window processes the t_data structure andimplements the transition using OpenGL calls. The code extract belowillustrates the initialisation of the DM (Display Manager) window with ascatter_(—)3D_cbDM( ) callback 44. scene_list[i].t_data->cllbckDMitem =_addwindowDM     (     Rect.left,     Rect.top,     scatter_3D_cbDM,    DI_ALPHA,     i,     get_priority(i),    Rect.top>=0?DM_BOTTOM_SCREEN:DM_TOP_SCREEN     );

Below is a list of the associated 3D callback functions 44 for eachtransition. Transition 3D Callback WIPE (any diagonal direction)diag_wipe_3D_cbDM SCATTER scatter_3D_cbDM IRIS iris_3D_cbDM CURTAIN(type 2) curtain2_3D_cbDM CURTAIN (type 1) curtain1_3D_cbDM

Referring to FIGS. 4 to 6, not all transitions require their owncallbacks 44 in 3D mode. This is determined according to theimplementation or specification of individual transitions. For example,the Wipe transition in any non-diagonal direction uses micro clipping.Thus for this transition there is no need for OpenGL operations.

Referring to FIG. 4, _refreshDM( ) 43 does not call a 3D transitioncallback 44 since transition_actions( ) 32 has ensured that thetransition data (t_data) has been updated or modified for the nextrefresh of the display 18. This is different to the scenario shown inFIG. 2. Also, in this scenario, the application code 25 and thescene_update_task 30 threads do not run concurrently and thescene3d_update_task thread 40 also does not run concurrently.

Referring to FIG. 5, _refreshDM( ) 43 is called in the context of thescene_update_task thread 30. There are also no 3D callbacks in 2D modeand transition_actions( ) 32 has ensured that the transition data(t_data) is updated and modified for the next refresh. Also, theapplication code 25 and scene_update_task( ) 30 threads do not runconcurrently.

Referring to FIG. 6, _refreshDM( ) 43 is called in the stream ofexecution for the diagonal wipe transition. When _refreshDM( ) 43 iscalled, each DM (Display Manager) item is drawn and checked to see if ithas a draw handler attached 60. If the image has a transition attachedto it then the attached draw handler is initiated 61. In the diagonalwipe transition, diag_wipe_(—)3D_cbDM( ) is called 61. The Wipetransition is drawn using OpenGL calls 62. The code extract belowillustrates the operation of _refreshDM( ) 43 with draw handlers. for (i= 1; i < DmItemsUsed; i++) {   ...   if (pItem->pDrawHnd &&(pItem->WhichScreen &   DM_BOTTOM_SCREEN))   {   (pItem->pDrawHnd)(hBack,       pItem->Rect.left,       pItem->Rect.top,      pItem->DrawMode,       pItem->Val);      continue;   } }

Referring to FIG. 7, the original image is copied into temporary memory71 for a diagonal wipe transition in 2D mode. The duplicate image isadded to the display 18 over the original image 72 and the originalimage is removed 73 from the display 18. The wipe increment iscalculated according to the formula shown at step 74. The amount of theimage that has been “wiped” is stored in the variable wipe dist, and isincremented at step 75. Then, pixel commands cause successive lines todisappear from the temporary image 76 on the gaming machine display 18.When waiting 77 for the next refresh of the display 18, the variablewipe dist is compared with the variable img width to determine if more“wiping” is necessary 78. If the value of wipe dist is not equal to theimg width variable, steps 75 to 78 are repeated. However, if wipe distis equal to img width, the temporary image is removed and the temporarymemory is released 79 ending the transition 80.

In 3D mode, different commands are used for step 76 instead of pixelcommands to draw the transition. For example, OpenGL triangle commandscould be used.

Scatter Transition Example

The Scatter transition receives a value (direction parameter) from the_addtransition( ) function 32. The direction parameter value is the sizeof the individual scattered squares, which is represented as a 1000^(th)of a percent of the image area. For example, a value of 2500 is a squaresize that is 25% of the image area. The Scatter transition thendetermines the number of squares needed for the transition andcalculates the position of the top left corner of each square 81 andassigns this value to each square. FIG. 8 illustrates the separation ofthe image by the Scatter transition. The lists of squares (1−n) arerandomly selected so that a random square is deleted from the image.

The t_data structure for the Scatter transition has eight variables thatare used for cumulative transition calculations. It is not known untilthe implementation of the transition algorithm is complete whether morevariables are required.

Transition_actions( ) 32 is modified for the Scatter transition. Thismodification includes the transition algorithm and the correct timing,so that the transition is completed within a user specified time. Belowis an excerpt of the initialisation of the scatter transition intransition_actions( ) 32. case SCATTER: {   if (t_data->generic1 == 0 &&t_data->generic2 == 0)   {     /* get square size based on area of image*/     img_area = width * height;     square_size = img_area *t_data->direction / 10000;     // generic5 is the square size.    square_size = t_data->generic5 = mborg_isqrt((long)square_size);    // generic3 is the number of x divisions. generic4 is the number ofy divisions     t_data->generic3 = (width % square_size != 0) ? width /square_size + 1 width / square_size;     t_data->generic4 = (height %square_size != 0) ? height / square_size + 1 height / square_size;    no_of_squares = t_data->generic3 * t_data->generic4;     /* allocatespace for rand numbers */     t_data->randomlist =avlmalloc(sizeof(NLIST)*no_of_squares);     make_rand_array(square_size,no_of_squares, t_data->randomlist, width, t_data- >generic3);     if(Is3D)     {      RECT Rect;     _getitempositionDM(scene_list[i].imagelist[0], &Rect);     scene_list[i].t_data->cllbckDMitem = addwindowDM       (      Rect.left,       Rect.top,       scatter_3D_cbDM,       DI_ALPHA,      i,       get_priority(i),       Rect.top>=0?DM_BOTTOM_SCREEN:DM_TOP_SCREEN       );     _invalidateitemDM(scene_list[i].t_data->cllbckDMitem, 0);     uninvalidateitemDM(scene_list[i].imagelist[0]);     t_data->randomlist3D = avlmalloc(sizeof(int) * no_of_squares);     for (j = 0; j < no_of_squares; j++)       t_data->randomlist3D[j] =1;     } } ...

To illustrate the process of initialisation, the code above is executedonce at the start of the transition to split up the image into numberedsquares as shown in FIG. 8.

Also, during initialisation, a Display Manager window is created for a3D callback 44.

Generally, each transition has a shape that is derived from thetransition. For example, the iris wipe transition has a circle and thewipe has a line. For the Scatter transition, this is a square. Inrelation to timing, the number of squares to remove per refresh periodis based on the duration value passed from _addtransition( ) 26. Thecode extract below illustrates the number of squares to remove perrefresh period (spf). /* timing */ lpf_1000 = ((no_of_squares * fbp) /t_data->duration); t_data->generic2 += lpf_1000; spf = t_data->generic2/ 1000; t_data->generic2 %= 1000;

The 1pf₁₃ 1000 variable holds the squares to remove per refresh periodx1000 to reduce rounding errors. The 1pf_(—)1000 variable is added tothe t_data>generic2 variable which is divided by 1000 to produce thefinal value for the number of squares to be removed for the currentrefresh period (spf). The remaining lines are stored in t_data->generic2 for the next refresh period.

Once the spf is calculated, a for loop is executed to remove a certainnumber of squares from the image per refresh period. The following codesegment illustrates this. for(j=0;j<spf;j++) {   /* create randomrectangle to clear */   area.left =t_data->randomlist[t_data->generic1].x − x_offset;   area.top =t_data->randomlist[t_data->generic1].y − y_offset;   area.right =t_data->randomlist[t_data->generic1].x +   t_data->generic5 − x_offset;  area.bottom = t_data->randomlist[t_data->generic1].y +  t_data->generic5 − y_offset;   /* for squares that fall off the DC */  area.left = (area.left <0) ? 0 : area.left;   area.top = (area.top <0)? 0 : area.top;   area.right = (area.right > width) ? width :area.right;   area.bottom = (area.bottom > height) ? height :area.bottom;   SoftFill(scene->playDc[0],&area,0);   t_data->generic1++;  if(t_data->generic1 == no_of_squares)   {     remove=TRUE;     /* freeall dynamic allocated memory */     _avlfree(t_data->randomlist);    t_data->randomlist = (NLIST *) 0;     break;   } }

Referring to FIG. 9, there are different drawing procedures depending onwhether the transition is in 2D mode or 3D mode. In 2D mode, SoftFill( )90 is called to fill a rectangle. FIG. 8 illustrates the division of theimage into many smaller squares. A random number is chosen and therectangle coordinates are calculated and put into a RECT structure. TheSoftFill( ) function 90 is called in the following way:SoftFill(scene->playDc[0],&area,0);

SoftFill( ) 90 instructs the current DC (Device Context) to set eachpixel to ‘0’ in the given rectangle ‘area’. The for loop may getexecuted n times per refresh period. In this case, SoftFill( ) 90 fillsn rectangles that are chosen randomly at each refresh period.

In 3D mode, a specific 3D callback, scatter _(—)3D_cbDM 44 is called 91via _refreshDM( ) 43. This function 44 which performs its own OpenGLoperations and divides the image into little triangles forming squares.To draw the transition image, less and less of the image is drawn eachrefresh period.

When the transition has ended it is removed from the DM (DisplayManager). In 2D mode, t_data->genericl is incremented each time theSoftFill( ) function 90 is called in the for loop. The t_data->genericlvariable indicates the number of squares that have been removed already.When the t_data->genericl variable reaches the number of squares thatexist, the image is removed. The code extract below illustrates this:if(t_data->genericl == no_of_squares) {   remove=TRUE;   /* free alldynamic allocated memory */   _avlfree(t_data->randomlist);  t_data->randomlist = (NLIST *) 0;   break; }

Once the remove variable is set to true, transition_actions( ) 32removes the transition from the DM (Display Manager) and cleans up thecode. The user may also want their own clean up code, as shown in thecode extract above. The clean up code also frees the memory that wasallocated for the random list of integers.

Although the Scatter transition has been described, it will beappreciated that other transitions are also envisaged. New transitionscan be added by:

-   -   modifying the t_data structure to add additional t_data        variables,    -   adding the transition algorithm and timing to the        transition_actions( ) function 32, and    -   if necessary, creating a 3D callback 44 with the transition        algorithm and timing.

Referring to FIGS. 10 a-c, the Wipe transition is shown. A landscapeimage is gradually removed line by line from the bottom of the image,gradually exposing the underlying graphics.

Referring to FIGS. 11 a-c, the Fade transition is shown. The imagegradually fades until it is no longer visible.

Referring to FIGS. 12 a-c the Iris transition is shown. The landscapeimage is gradually removed by the appearance of a “hole” in the middleof the image. The hole grows until the entire image is replaced and theunderlying graphics wholly exposed.

It will be appreciated by persons skilled in the art that numerousvariations and/or modifications may be made to the invention as shown inthe specific embodiments without departing from the spirit or scope ofthe invention as broadly described. The present embodiments are,therefore, to be considered in all respects as illustrative and notrestrictive.

1. A graphics system for changing images on a gaming machine display,the system comprising: a transition library of transition types; agraphics engine to apply a selected transition type from the transitionlibrary to at least one of at least two images for determining the wayin which a substitution of one of the images by the other of the imagesoccurs and for initialising transition data for effecting an incrementalsubstitution of the one image by the other image; and a control meansfor modifying the transition data such that, when the selectedtransition type is being effected, an incremental substitution of atleast a part of the one image by the other image occurs serially untilthe one image has been substituted by the other image on the gamingmachine display.
 2. A graphics system according to claim 1 wherein asecond of the images is initially placed behind a first of the images.3. A graphics system according to claim 2 wherein the first image isincrementally removed by the transition type to reveal or expose atleast a part of the second image until the first image has been entirelyremoved to reveal the second image.
 4. A graphics system according toclaim 2 wherein the transition library has any one or more of thefollowing transition types: wipe, scatter, fade, iris, shrink, curtain,rotate.
 5. A graphics system according to claim 4 wherein the selectedtransition type changes the first image to the second image using ashape.
 6. A graphics system according to claim 5 wherein the iristransition type uses a circle.
 7. A graphics system according to claim 5wherein the wipe transition type uses a line.
 8. A graphics systemaccording to claim 5 wherein the scatter transition type uses a square.9. A graphics system according to claim 2 wherein the selectedtransition type is drawn using any one or more of pixel operations,scaling operations, microclipping operations or OpenGL operations.
 10. Agraphics system according to claim 2 wherein the selected transitiontype has a predetermined duration.
 11. A graphics system according toclaim 2 wherein the selected transition type coincides with a sound oranimation.
 12. A graphics system according to claim 2 wherein theselected transition type starts and resets based on a predeterminedtime.
 13. A graphics system according to claim 2 wherein at least one ofthe images is an animation.
 14. A graphics system according to claim 13wherein the second image is an animation.
 15. A graphics systemaccording to claim 2 wherein the first image or the second image is a 2Dimage or a 3D image.
 16. A graphics system according to claim 15 whereinthe selected transition type is in 2D mode where either the first imageor the second image is a 2D image.
 17. A graphics system according toclaim 15 wherein in 2D mode the first image or the second image isdivided into small shapes.
 18. A graphics system according to claim 17wherein a predetermined number of small shapes are filled for eachrefresh period of the gaming machine display.
 19. A graphics systemaccording to claim 15 wherein the selected transition type is in 3D modewhere either the first image or the second image is a 3D image.
 20. Agraphics system according to claim 19 wherein in 3D mode the transitiondata includes a callback function that is attached to the selectedtransition type.
 21. A graphics system according to claim 20 wherein aDisplay Manager window is created for the callback function.
 22. Agraphics system according to claim 21 wherein the callback functiondraws the selected transition type on the gaming machine display usingOpenGL calls.
 23. A graphics system according to claim 22 wherein thecallback function draws the selected transition type on the gamingmachine display by incrementally exposing less of the first image foreach refresh period of the gaming machine display.
 24. A graphics systemaccording to claim 18 wherein the first image exists in a scene list.25. A graphics system according to claim 24 wherein the selectedtransition type is added in the same position of the first image in thescene list.
 26. A graphics system according to claim 25 wherein aduplicate image of the first image is added to the scene list formodification.
 27. A graphics system according to claim 26 wherein thetransition data for the duplicate image is initialised.
 28. A graphicssystem according to claim 27 wherein the transition data is theduplicate image of the first image.
 29. A graphics system according toclaim 28 wherein the transition data is generated or modified at everyrefresh period of the gaming machine display.
 30. A graphics systemaccording to claim 26 wherein an offscreen Device Context is created forreceiving a copy of the duplicate image.
 31. A graphics system accordingto claim 30 wherein the first image is removed after the Device Contextis created.
 32. A graphics system according to claim 30 wherein theduplicate image in the offscreen Device Context is added to a DisplayManager.
 33. A graphics system according to claim 32 wherein theduplicate image is removed from the Display Manager when the selectedtransition type is completed.
 34. A graphics system according to claim24 wherein each image in the scene list is checked to determine if theimage has transition data.
 35. A graphics system according to claim 34wherein each image that has transition data has a draw handler.
 36. Agraphics system according to claim 18 wherein parts of the first imageto be replaced per refresh period are determined such that the selectedtransition type is completed within a predetermined period of time. 37.A graphics system according to claim 36 wherein the predetermined periodof time is set by a user at run-time.
 38. A graphics system according toclaim 2 wherein the transition data includes any one or more of thetransition type, the duration of the selected transition type or thecurrent state of the selected transition.
 39. A method for changingimages on a gaming machine display, the method comprising the steps of:selecting a transition type from a transition library of transitiontypes; applying the selected transition type to at least one of at leasttwo images for determining the way in which a substitution of one of theimages by the other of the images occurs; initialising transition datafor effecting an incremental substitution of the one image by the otherimage; and modifying the transition data such that, when the selectedtransition type is being effected, an incremental substitution of atleast a part of the one image by the other image occurs serially untilthe one image has been substituted by the other image on the gamingmachine display.
 40. A method according to claim 39 wherein a second ofthe images is initially placed behind a first of the images.
 41. Amethod according to claim 40 further comprising the step ofincrementally removing the first image using the transition type toreveal or expose at least a part of the second image until the firstimage has been entirely removed to reveal the second image.
 42. A methodaccording to claim 41 further comprising the step of the selectedtransition type using a shape to change the first image to the secondimage.
 43. A method according to claim 40 further comprising the step ofdrawing the selected transition type using any one or more of pixeloperations, scaling operations, microclipping operations or OpenGLoperations.
 44. A method according to claim 40 wherein the first imageor the second image is a 2D image and the selected transition type is ina 2D mode, the method further comprising the step of dividing the firstimage or the second image into small shapes.
 45. A method according toclaim 44 further comprising the step of filling a predetermined numberof the small shapes for each refresh period of the game machine display.46. A method according to claim 40 wherein the first image or the secondimage is a 3D image and the selected transition type is in a 3D mode,the method further comprising the step of attaching to the selectedtransition type a callback function forming a part of the transitiondata.
 47. A method according to claim 46 further comprising the step ofcreating a Display Manager window for the callback function.
 48. Amethod according to claim 47 further comprising the step of the callbackfunction drawing the selected transition type on the gaming machinedisplay using OpenGL calls.
 49. A method according to claim 48 whereinthe step of drawing is performed by incrementally exposing less of thefirst image for each refresh period of the gaming machine display.
 50. Amethod according to claim 40 wherein the first image exists in a scenelist, the method further comprising the step of adding the selectedtransition type in the same position of the first image in the scenelist.
 51. A method according to claim 50 further comprising the step ofadding a duplicate image of the first image to the scene list formodification.
 52. A method according to claim 51 further comprising thestep of initialising the transition data for the duplicate image.
 53. Amethod according to claim 51 further comprising the step of generatingor modifying the transition data at every refresh period of the gamingmachine display.
 54. A method according to claim 50 further comprisingthe step of creating an offscreen Device Context for receiving a copy ofthe duplicate image.
 55. A method according to claim 54 furthercomprising the step of removing the first image after the Device Contextis created.
 56. A method according to claim 55 further comprising thestep of adding the duplicate image in the offscreen Device Context to aDisplay Manager.
 57. A method according to claim 56 further comprisingthe step of removing the duplicate image from the Display Manager whenthe selected transition type is completed.
 58. A method according toclaim 50 further comprising the step of checking each image in the scenelist to determine if the image has transition data.
 59. A methodaccording to claim 58 wherein parts of the first image to be replacedper refresh period are determined such that the selected transition typeis completed within a predetermined period of time.
 60. Computer programmeans for directing a graphics engine and a control means to execute aprocedure to change images in a graphics system on a gaming machinedisplay, the graphics system having a transition library of transitiontypes, the computer program means directing: the graphics engine toapply a selected transition type from the transition library to at leastone of at least two images for determining the way in which asubstitution of one of the images by the other of the images occurs andfor initialising transition data for effecting an incrementalsubstitution of the one image by the other image; the computer programmeans further directing the control means to modify the transition datasuch that when the selected transition type is being effected, anincremental substitution of at least a part of the one image by theother image occurs serially until the one image has been substituted bythe other image on the gaming machine display.
 61. Computer programmeans for directing a graphics engine and a control means to execute aprocedure to change images on a gaming machine display by: selecting atransition type from a transition library of transition types; applyingthe selected transition type to at least one of at least two images fordetermining the way in which a substitution of one of the images by theother of the images occurs; initialising transition data for effectingan incremental substitution of the one image by the other image; andmodifying the transition data such that when the selected transitiontype is being effected, an incremental substitution of at least a partof the one image by the other image occurs serially until the one imagehas been substituted by the other image on the gaming machine display.62. (canceled)
 63. A computer readable memory, encoded with datarepresenting a computer program for directing a graphics engine and acontrol means to execute a procedure to change images on a gamingmachine display by: selecting a transition type from a transitionlibrary of transition types; applying the selected transition type to atleast one of at least two images for determining the way in which asubstitution of one of the images by the other of the images occurs;initialising transition data for effecting an incremental substitutionof the one image by the other image; and modifying the transition datasuch that when the selected transition type is being effected, anincremental substitution of at least a part of the one image by theother image occurs serially until the one image has been substituted bythe other image on the gaming machine display.
 64. (canceled)
 65. Agaming machine having a gaming machine display, the gaming machinecomprising: a graphics system to change images on the gaming machinedisplay, the graphics system including: a transition library oftransition types; a graphics engine for applying a selected transitiontype from the transition library to at least one of at least two imagesfor determining the way in which a substitution of one of the images bythe other of the images occurs and for initialising transition data foreffecting an incremental substitution of the one image by the otherimage; and a control means for modifying the transition data such that,when the selected transition type is being effected, an incrementalsubstitution of at least a part of the one image by the other imageoccurs serially until the one image has been substituted by the otherimage on the gaming machine display.